<template>
    <div class="demo-collapse">
        <el-collapse v-model="activeNames" @change="handleChange">
            <el-collapse-item title="解题思路" name="thinking">
                <div>
                    <div>
                        归并排序的基本思路是将待排序的数组分成两个部分，分别对这两部分进行排序，
                        然后将排好序的两部分合并成一个有序数组。这个过程可以用递归来实现。具体的实现步骤如下：
                    </div>
                    <div>
                        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;分解：将待排序的数组不断分成两个子数组，直到每个子数组只有一个元素为止。
                    </div>
                    <div>
                        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;合并：将相邻的两个子数组合并成一个有序数组，直到最后只剩下一个有序数组为止。
                    </div>
                    <div>
                        合并的过程中，需要用到一个辅助数组来暂存合并后的有序数组。具体来说，假设待合并的两个有序数组分别为 A 和 B，它们的长度分别为 n 和 m，
                        合并后的有序数组为 C，那么合并的过程可以按如下步骤进行：
                    </div>
                    <div>
                        （1）定义三个指针 i、j 和 k，分别指向数组 A、B 和 C 的起始位置。<br>
                        （2）比较 A[i] 和 B[j] 的大小，将小的元素放入 C[k] 中，并将对应指针向后移动一位。<br>
                        （3）重复步骤 2，直到其中一个数组的元素全部放入 C 中。<br>
                        （4）将另一个数组中剩余的元素放入 C 中。
                    </div>
                </div>
            </el-collapse-item>
            <el-collapse-item title="代码实现" name="code">
                <!-- <el-image style="width:100%" :src="url" :fit="fit" loading="lazy"></el-image> -->
                <div v-highlight>
                    <div>C/C++:</div>
                    <pre class="language-javascript">
                      <code>
                        #include &lt;stdio.h>
                            #include &lt;iostream>
                            #include &lt;algorithm>
                            #include &lt;cstdlib>
                            #include &lt;cmath>
                            using namespace std;
                            void merge(int* a, int low, int mid, int hight)  //合并函数
                            {
                                int* b = new int[hight - low + 1];  //用 new 申请一个辅助函数
                                int i = low, j = mid + 1, k = 0;    // k为 b 数组的小标
                                while (i &lt;= mid && j &lt;= hight)  
                                {
                                    if (a[i] &lt;= a[j])
                                    {
                                        b[k++] = a[i++];  //按从小到大存放在 b 数组里面
                                    }
                                    else
                                    {
                                        b[k++] = a[j++];
                                    }
                                }
                                while (i &lt;= mid)  // j 序列结束，将剩余的 i 序列补充在 b 数组中 
                                {
                                    b[k++] = a[i++];
                                }
                                while (j &lt;= hight)// i 序列结束，将剩余的 j 序列补充在 b 数组中 
                                {
                                    b[k++] = a[j++];
                                }
                                k = 0;  //从小标为 0 开始传送
                                for (int i = low; i &lt;= hight; i++)  //将 b 数组的值传递给数组 a
                                {
                                    a[i] = b[k++];
                                }
                                delete[]b;     // 辅助数组用完后，将其的空间进行释放（销毁）
                            }
                            void mergesort(int* a, int low, int hight) //归并排序
                            {
                                if (low &lt; hight)
                                {
                                    int mid = (low + hight) / 2;
                                    mergesort(a, low, mid);          //对 a[low,mid]进行排序
                                    mergesort(a, mid + 1, hight);    //对 a[mid+1,hight]进行排序
                                    merge(a, low, mid, hight);       //进行合并操作
                                }
                            }
                            int main()
                            {
                                int n, a[100];
                                cout &lt; "请输入数列中的元素个数 n 为：" &lt;&lt; endl;
                                cin >> n;
                                cout &lt;&lt; "请依次输入数列中的元素：" &lt;&lt; endl;
                                for (int i = 0; i &lt; n; i++)
                                {
                                    cin >> a[i];
                                }
                                mergesort(a, 0, n-1);
                                cout &lt;&lt; "归并排序结果" &lt;&lt; endl;
                                for (int i = 0; i &lt; n; i++)
                                {
                                    cout &lt;&lt; a[i] &lt;&lt; " ";
                                }
                                cout &lt;&lt; endl;
                                return 0;
                            }
                      </code>
                    </pre>
                </div>
                <div v-highlight>
                    <div>Python:</div>
                    <pre class="language-javascript">
                        <code>
                            def merge_sort(arr):
                                if len(arr) &lt;= 1:
                                    return arr
 
                                # 将数组分成两个部分
                                mid = len(arr) // 2
                                left_half = arr[:mid]
                                right_half = arr[mid:]
 
                                # 对左右两部分分别递归调用归并排序
                                left_half = merge_sort(left_half)
                                right_half = merge_sort(right_half)
 
                                # 合并左右两部分
                                return merge(left_half, right_half)
 
                            def merge(left_half, right_half):
                                i = j = 0
                                merged = []
 
                                # 比较左右两部分的元素，将较小的元素添加到 merged 中
                                                            while i &lt; len(left_half) and j &lt; len(right_half):
                                    if left_half[i] &lt; right_half[j]:
                                        merged.append(left_half[i])
                                        i += 1
                                    else:
                                        merged.append(right_half[j])
                                        j += 1
 
                                # 将左右两部分中剩余的元素添加到 merged 中
                                merged += left_half[i:]
                                merged += right_half[j:]
 
                                return merged
                        </code>
                    </pre>
                </div>
                <div v-highlight>
                    <div>Java:</div>
                    <pre class="language-javascript">
                      <code>
                        public class MergeSort {
                            public static void main(String[] args) {
                                int[] arr = {3, 5, 1, 9, 7, 2, 8, 4, 6};
                                mergeSort(arr, 0, arr.length - 1);
                                System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9]
                            }
                         
                            public static void mergeSort(int[] arr, int left, int right) {
                                if (left >= right) {
                                    return;
                                }
                         
                                int mid = (left + right) / 2;
                                mergeSort(arr, left, mid);
                                mergeSort(arr, mid + 1, right);
                                merge(arr, left, mid, right);
                            }
                         
                            public static void merge(int[] arr, int left, int mid, int right) {
                                int[] temp = new int[right - left + 1];
                                int i = left, j = mid + 1, k = 0;
                         
                                while (i &lt;= mid && j &lt;= right) {
                                    if (arr[i] &lt; arr[j]) {
                                        temp[k++] = arr[i++];
                                    } else {
                                        temp[k++] = arr[j++];
                                    }
                                }
                         
                                while (i &lt;= mid) {
                                    temp[k++] = arr[i++];
                                }
                         
                                while (j &lt;= right) {
                                    temp[k++] = arr[j++];
                                }
                         
                                for (int m = 0; m &lt; temp.length; m++) {
                                    arr[left + m] = temp[m];
                                }
                            }
                        }
                      </code>
                    </pre>
                </div>
            </el-collapse-item>
        </el-collapse>
    </div>
</template>

<script lang="ts" setup>
import { ref } from 'vue'
// const url='../assets/code/汉诺塔.png'
const activeNames = ref(['thinking'])
const handleChange = (val: string[]) => {
    console.log(val)
}
// 代码实现部分
import "vue-code-highlight/themes/prism-solarizedlight.css";
import "vue-code-highlight/themes/window.css";

</script>
